"""
股票流动性分析器
根据历史成交量、成交额等指标对股票流动性进行分类
"""
import logging
import numpy as np
import pandas as pd
from typing import Optional

logger = logging.getLogger('LiquidityAnalyzer')


class StockLiquidityAnalyzer:
    """
    股票流动性分析器
    基于多个指标对股票流动性进行综合评估
    """
    
    def __init__(self, 
                 high_volume_threshold: int = 5000000,
                 medium_volume_threshold: int = 1000000,
                 lookback_days: int = 20):
        """
        Args:
            high_volume_threshold: 高流动性成交量阈值（股）
            medium_volume_threshold: 中等流动性成交量阈值（股）
            lookback_days: 回看天数
        """
        self.high_threshold = high_volume_threshold
        self.medium_threshold = medium_volume_threshold
        self.lookback_days = lookback_days
        self.cache = {}  # 缓存流动性分类结果
    
    def classify(self, 
                stock_data: pd.DataFrame, 
                current_index: int, 
                stock_code: Optional[str] = None) -> str:
        """
        分类股票流动性
        
        Args:
            stock_data: 股票数据
            current_index: 当前索引
            stock_code: 股票代码（用于缓存）
            
        Returns:
            str: 流动性等级 'high' | 'medium' | 'low'
        """
        # 使用缓存避免重复计算
        cache_key = f"{stock_code}_{current_index}" if stock_code else str(current_index)
        if cache_key in self.cache:
            return self.cache[cache_key]
        
        # 数据不足时返回默认值
        if current_index < min(self.lookback_days, 10):
            return 'medium'
        
        result = self._classify_by_multiple_indicators(stock_data, current_index)
        
        # 缓存结果
        self.cache[cache_key] = result
        return result
    
    def _classify_by_multiple_indicators(self, 
                                        stock_data: pd.DataFrame, 
                                        current_index: int) -> str:
        """
        基于多个指标综合评估流动性
        
        Returns:
            str: 流动性等级
        """
        try:
            lookback = min(self.lookback_days, current_index)
            recent_data = stock_data.iloc[max(0, current_index-lookback):current_index]
            
            if len(recent_data) == 0:
                return 'medium'
            
            # 指标1: 平均成交量
            avg_volume = recent_data['volume'].mean()
            
            # 指标2: 成交量稳定性（变异系数 CV = std/mean）
            volume_cv = recent_data['volume'].std() / avg_volume if avg_volume > 0 else 1.0
            
            # 指标3: 平均成交额（价格 * 成交量）
            avg_turnover = (recent_data['close'] * recent_data['volume']).mean()
            
            # 综合评分（0-5分）
            score = 0
            
            # 成交量评分
            if avg_volume > self.high_threshold:
                score += 3
            elif avg_volume > self.medium_threshold:
                score += 2
            else:
                score += 1
            
            # 稳定性评分（成交量稳定性高，流动性更可靠）
            if volume_cv < 0.5:  # 成交量稳定
                score += 1
            
            # 成交额评分
            if avg_turnover > 50000000:  # 成交额大于5000万
                score += 1
            
            # 根据评分分类
            if score >= 4:
                return 'high'
            elif score >= 2:
                return 'medium'
            else:
                return 'low'
                
        except Exception as e:
            logger.warning(f"流动性分类异常: {e}")
            return 'medium'  # 异常时返回默认值
    
    def clear_cache(self):
        """清空缓存"""
        self.cache.clear()

